rpc/jsonrpc: fail trace_filter instead of mixing error objects into the result array - #23346

Fixes #23128

Problem

trace_filter documents its result as Array<TraceEntry>, but filterV3 wrote per-transaction failures into that array as bare error objects and kept iterating, so the envelope still reported success:

"result":[
  {"action":{…},"type":"reward","blockNumber":1},
  {"error":{"code":-32000,"message":"protected txn is not supported by signer …"}},
  {"action":{…},"type":"reward","blockNumber":3}
]

That item has no type, action or traceAddress, so a strict decoder breaks on it and a lenient one accepts a partial trace as complete. Thirteen failure paths behaved this way: iterator Next, HeaderByNumber, missing header, Body, three json.Marshal calls, TxnByIdxInBlock, AsMessage, and traceFilterTxn's timeout, execution, FinalizeTx and CommitBlock paths — the last four sharing a writeErr closure.

What other clients do

trace_* is not part of execution-apis, which covers eth, debug, engine and txpool only, so there is no official schema to conform to. The de-facto reference is OpenEthereum's trace module, which documents the result as plain "Array — Traces matching given filter", with no error variant among the items.

• reth: async fn trace_filter(&self, filter: TraceFilter) -> RpcResult<Vec<LocalizedTransactionTrace>> — the item type is fixed, so a failure can only surface through RpcResult, i.e. as a JSON-RPC error.
• Nethermind: ResultWrapper<IEnumerable<ParityTxTraceFromStore>> trace_filter(...) — a block it cannot resolve returns ResultWrapper.Fail, failing the whole request; missing state truncates the stream with a warning. Either way no error item enters the array.

Decision

#23128 asked us to choose one explicit result contract out of three:

1. fail the JSON-RPC request when a transaction cannot be traced;
2. return only valid TraceEntry items and expose partial failures separately;
3. document a union element type such as TraceEntry | TraceItemError, including how clients should detect incomplete results.

This PR implements the first one. It is what reth and Nethermind already do, so it aligns us with the de-facto contract instead of inventing a third dialect.

Fix

Every one of those paths now propagates the error instead of writing into the array, and traceFilterTxn drops both its writeErr closure and the (nil, nil) "error already on the stream" convention it relied on.

The result array opens on the first exported trace instead of up front. runMethod wraps the handler's stream in a LazyFieldStream, so a field nobody writes to is never emitted, and an error raised before any trace yields an error-only response. Keeping the array open from the start would instead have paired an empty result with the error. When traces were already streamed, runMethod's rs.CloseIfOpen() → StackStream.ClosePending seals the half-written array.

Tests

TestFilterSignerReflectsBlockOverridesNumber is inverted: it asserted the error text showed up inside the stream, it now asserts the call fails and the stream stays empty.

TestFilterErrorAfterExportedTracesKeepsValidJSON is new and covers the error arriving after traces were streamed. Filtering blocks 1-3 with no address filter exports both empty blocks' reward traces before block 3's EIP-155-protected transaction is rejected by the overridden pre-Spurious-Dragon signer. The envelope is assembled the way runMethod does it, since sealing the array is the handler's job rather than filterV3's; this follows the existing TestTraceBlockErrorAfterWrite pattern. It asserts the envelope parses, the result array parses (i.e. ClosePending closed it), every item has type, and any error present decodes as a string rather than an object.

Both were confirmed red against main — each fails on An error is expected but got nil — and with that assertion relaxed the new one reproduces the malformed array above.